( function () {
/**
 * Dependencies
 *  - Ammo.js https://github.com/kripken/ammo.js
 *
 * MMDPhysics calculates physics with Ammo(Bullet based JavaScript Physics engine)
 * for MMD model loaded by MMDLoader.
 *
 * TODO
 *  - Physics in Worker
 */

/* global Ammo */

class MMDPhysics {
  /**
   * @param {THREE.SkinnedMesh} mesh
   * @param {Array<Object>} rigidBodyParams
   * @param {Array<Object>} (optional) constraintParams
   * @param {Object} params - (optional)
   * @param {Number} params.unitStep - Default is 1 / 65.
   * @param {Integer} params.maxStepNum - Default is 3.
   * @param {Vector3} params.gravity - Default is ( 0, - 9.8 * 10, 0 )
   */
  constructor(mesh, rigidBodyParams, constraintParams = [], params = {}) {
    if (typeof Ammo === 'undefined') {
      throw new Error('THREE.MMDPhysics: Import ammo.js https://github.com/kripken/ammo.js');
    }

    this.manager = new ResourceManager();
    this.mesh = mesh;
    /*
     * I don't know why but 1/60 unitStep easily breaks models
     * so I set it 1/65 so far.
     * Don't set too small unitStep because
     * the smaller unitStep can make the performance worse.
     */

    this.unitStep = params.unitStep !== undefined ? params.unitStep : 1 / 65;
    this.maxStepNum = params.maxStepNum !== undefined ? params.maxStepNum : 3;
    this.gravity = new THREE.Vector3(0, -9.8 * 10, 0);
    if (params.gravity !== undefined) this.gravity.copy(params.gravity);
    this.world = params.world !== undefined ? params.world : null; // experimental

    this.bodies = [];
    this.constraints = [];

    this._init(mesh, rigidBodyParams, constraintParams);
  }
  /**
   * Advances Physics calculation and updates bones.
   *
   * @param {Number} delta - time in second
   * @return {MMDPhysics}
   */


  update(delta) {
    const manager = this.manager;
    const mesh = this.mesh; // rigid bodies and constrains are for
    // mesh's world scale (1, 1, 1).
    // Convert to (1, 1, 1) if it isn't.

    let isNonDefaultScale = false;
    const position = manager.allocThreeVector3();
    const quaternion = manager.allocThreeQuaternion();
    const scale = manager.allocThreeVector3();
    mesh.matrixWorld.decompose(position, quaternion, scale);

    if (scale.x !== 1 || scale.y !== 1 || scale.z !== 1) {
      isNonDefaultScale = true;
    }

    let parent;

    if (isNonDefaultScale) {
      parent = mesh.parent;
      if (parent !== null) mesh.parent = null;
      scale.copy(this.mesh.scale);
      mesh.scale.set(1, 1, 1);
      mesh.updateMatrixWorld(true);
    } // calculate physics and update bones


    this._updateRigidBodies();

    this._stepSimulation(delta);

    this._updateBones(); // restore mesh if converted above


    if (isNonDefaultScale) {
      if (parent !== null) mesh.parent = parent;
      mesh.scale.copy(scale);
    }

    manager.freeThreeVector3(scale);
    manager.freeThreeQuaternion(quaternion);
    manager.freeThreeVector3(position);
    return this;
  }
  /**
   * Resets rigid bodies transorm to current bone's.
   *
   * @return {MMDPhysics}
   */


  reset() {
    for (let i = 0, il = this.bodies.length; i < il; i++) {
      this.bodies[i].reset();
    }

    return this;
  }
  /**
   * Warm ups Rigid bodies. Calculates cycles steps.
   *
   * @param {Integer} cycles
   * @return {MMDPhysics}
   */


  warmup(cycles) {
    for (let i = 0; i < cycles; i++) {
      this.update(1 / 60);
    }

    return this;
  }
  /**
   * Sets gravity.
   *
   * @param {Vector3} gravity
   * @return {MMDPhysicsHelper}
   */


  setGravity(gravity) {
    this.world.setGravity(new Ammo.btVector3(gravity.x, gravity.y, gravity.z));
    this.gravity.copy(gravity);
    return this;
  }
  /**
   * Creates MMDPhysicsHelper
   *
   * @return {MMDPhysicsHelper}
   */


  createHelper() {
    return new MMDPhysicsHelper(this.mesh, this);
  } // private methods


  _init(mesh, rigidBodyParams, constraintParams) {
    const manager = this.manager; // rigid body/constraint parameters are for
    // mesh's default world transform as position(0, 0, 0),
    // quaternion(0, 0, 0, 1) and scale(0, 0, 0)

    let parent = mesh.parent;
    if (parent !== null) parent = null;
    const currentPosition = manager.allocThreeVector3();
    const currentQuaternion = manager.allocThreeQuaternion();
    const currentScale = manager.allocThreeVector3();
    currentPosition.copy(mesh.position);
    currentQuaternion.copy(mesh.quaternion);
    currentScale.copy(mesh.scale);
    mesh.position.set(0, 0, 0);
    mesh.quaternion.set(0, 0, 0, 1);
    mesh.scale.set(1, 1, 1);
    mesh.updateMatrixWorld(true);

    if (this.world === null) {
      this.world = this._createWorld();
      this.setGravity(this.gravity);
    }

    this._initRigidBodies(rigidBodyParams);

    this._initConstraints(constraintParams);

    if (parent !== null) mesh.parent = parent;
    mesh.position.copy(currentPosition);
    mesh.quaternion.copy(currentQuaternion);
    mesh.scale.copy(currentScale);
    mesh.updateMatrixWorld(true);
    this.reset();
    manager.freeThreeVector3(currentPosition);
    manager.freeThreeQuaternion(currentQuaternion);
    manager.freeThreeVector3(currentScale);
  }

  _createWorld() {
    const config = new Ammo.btDefaultCollisionConfiguration();
    const dispatcher = new Ammo.btCollisionDispatcher(config);
    const cache = new Ammo.btDbvtBroadphase();
    const solver = new Ammo.btSequentialImpulseConstraintSolver();
    const world = new Ammo.btDiscreteDynamicsWorld(dispatcher, cache, solver, config);
    return world;
  }

  _initRigidBodies(rigidBodies) {
    for (let i = 0, il = rigidBodies.length; i < il; i++) {
      this.bodies.push(new RigidBody(this.mesh, this.world, rigidBodies[i], this.manager));
    }
  }

  _initConstraints(constraints) {
    for (let i = 0, il = constraints.length; i < il; i++) {
      const params = constraints[i];
      const bodyA = this.bodies[params.rigidBodyIndex1];
      const bodyB = this.bodies[params.rigidBodyIndex2];
      this.constraints.push(new Constraint(this.mesh, this.world, bodyA, bodyB, params, this.manager));
    }
  }

  _stepSimulation(delta) {
    const unitStep = this.unitStep;
    let stepTime = delta;
    let maxStepNum = (delta / unitStep | 0) + 1;

    if (stepTime < unitStep) {
      stepTime = unitStep;
      maxStepNum = 1;
    }

    if (maxStepNum > this.maxStepNum) {
      maxStepNum = this.maxStepNum;
    }

    this.world.stepSimulation(stepTime, maxStepNum, unitStep);
  }

  _updateRigidBodies() {
    for (let i = 0, il = this.bodies.length; i < il; i++) {
      this.bodies[i].updateFromBone();
    }
  }

  _updateBones() {
    for (let i = 0, il = this.bodies.length; i < il; i++) {
      this.bodies[i].updateBone();
    }
  }

}
/**
 * This manager's responsibilies are
 *
 * 1. manage Ammo.js and Three.js object resources and
 *    improve the performance and the memory consumption by
 *    reusing objects.
 *
 * 2. provide simple Ammo object operations.
 */


class ResourceManager {
  constructor() {
    // for Three.js
    this.threeVector3s = [];
    this.threeMatrix4s = [];
    this.threeQuaternions = [];
    this.threeEulers = []; // for Ammo.js

    this.transforms = [];
    this.quaternions = [];
    this.vector3s = [];
  }

  allocThreeVector3() {
    return this.threeVector3s.length > 0 ? this.threeVector3s.pop() : new THREE.Vector3();
  }

  freeThreeVector3(v) {
    this.threeVector3s.push(v);
  }

  allocThreeMatrix4() {
    return this.threeMatrix4s.length > 0 ? this.threeMatrix4s.pop() : new THREE.Matrix4();
  }

  freeThreeMatrix4(m) {
    this.threeMatrix4s.push(m);
  }

  allocThreeQuaternion() {
    return this.threeQuaternions.length > 0 ? this.threeQuaternions.pop() : new THREE.Quaternion();
  }

  freeThreeQuaternion(q) {
    this.threeQuaternions.push(q);
  }

  allocThreeEuler() {
    return this.threeEulers.length > 0 ? this.threeEulers.pop() : new THREE.Euler();
  }

  freeThreeEuler(e) {
    this.threeEulers.push(e);
  }

  allocTransform() {
    return this.transforms.length > 0 ? this.transforms.pop() : new Ammo.btTransform();
  }

  freeTransform(t) {
    this.transforms.push(t);
  }

  allocQuaternion() {
    return this.quaternions.length > 0 ? this.quaternions.pop() : new Ammo.btQuaternion();
  }

  freeQuaternion(q) {
    this.quaternions.push(q);
  }

  allocVector3() {
    return this.vector3s.length > 0 ? this.vector3s.pop() : new Ammo.btVector3();
  }

  freeVector3(v) {
    this.vector3s.push(v);
  }

  setIdentity(t) {
    t.setIdentity();
  }

  getBasis(t) {
    var q = this.allocQuaternion();
    t.getBasis().getRotation(q);
    return q;
  }

  getBasisAsMatrix3(t) {
    var q = this.getBasis(t);
    var m = this.quaternionToMatrix3(q);
    this.freeQuaternion(q);
    return m;
  }

  getOrigin(t) {
    return t.getOrigin();
  }

  setOrigin(t, v) {
    t.getOrigin().setValue(v.x(), v.y(), v.z());
  }

  copyOrigin(t1, t2) {
    var o = t2.getOrigin();
    this.setOrigin(t1, o);
  }

  setBasis(t, q) {
    t.setRotation(q);
  }

  setBasisFromMatrix3(t, m) {
    var q = this.matrix3ToQuaternion(m);
    this.setBasis(t, q);
    this.freeQuaternion(q);
  }

  setOriginFromArray3(t, a) {
    t.getOrigin().setValue(a[0], a[1], a[2]);
  }

  setOriginFromThreeVector3(t, v) {
    t.getOrigin().setValue(v.x, v.y, v.z);
  }

  setBasisFromArray3(t, a) {
    var thQ = this.allocThreeQuaternion();
    var thE = this.allocThreeEuler();
    thE.set(a[0], a[1], a[2]);
    this.setBasisFromThreeQuaternion(t, thQ.setFromEuler(thE));
    this.freeThreeEuler(thE);
    this.freeThreeQuaternion(thQ);
  }

  setBasisFromThreeQuaternion(t, a) {
    var q = this.allocQuaternion();
    q.setX(a.x);
    q.setY(a.y);
    q.setZ(a.z);
    q.setW(a.w);
    this.setBasis(t, q);
    this.freeQuaternion(q);
  }

  multiplyTransforms(t1, t2) {
    var t = this.allocTransform();
    this.setIdentity(t);
    var m1 = this.getBasisAsMatrix3(t1);
    var m2 = this.getBasisAsMatrix3(t2);
    var o1 = this.getOrigin(t1);
    var o2 = this.getOrigin(t2);
    var v1 = this.multiplyMatrix3ByVector3(m1, o2);
    var v2 = this.addVector3(v1, o1);
    this.setOrigin(t, v2);
    var m3 = this.multiplyMatrices3(m1, m2);
    this.setBasisFromMatrix3(t, m3);
    this.freeVector3(v1);
    this.freeVector3(v2);
    return t;
  }

  inverseTransform(t) {
    var t2 = this.allocTransform();
    var m1 = this.getBasisAsMatrix3(t);
    var o = this.getOrigin(t);
    var m2 = this.transposeMatrix3(m1);
    var v1 = this.negativeVector3(o);
    var v2 = this.multiplyMatrix3ByVector3(m2, v1);
    this.setOrigin(t2, v2);
    this.setBasisFromMatrix3(t2, m2);
    this.freeVector3(v1);
    this.freeVector3(v2);
    return t2;
  }

  multiplyMatrices3(m1, m2) {
    var m3 = [];
    var v10 = this.rowOfMatrix3(m1, 0);
    var v11 = this.rowOfMatrix3(m1, 1);
    var v12 = this.rowOfMatrix3(m1, 2);
    var v20 = this.columnOfMatrix3(m2, 0);
    var v21 = this.columnOfMatrix3(m2, 1);
    var v22 = this.columnOfMatrix3(m2, 2);
    m3[0] = this.dotVectors3(v10, v20);
    m3[1] = this.dotVectors3(v10, v21);
    m3[2] = this.dotVectors3(v10, v22);
    m3[3] = this.dotVectors3(v11, v20);
    m3[4] = this.dotVectors3(v11, v21);
    m3[5] = this.dotVectors3(v11, v22);
    m3[6] = this.dotVectors3(v12, v20);
    m3[7] = this.dotVectors3(v12, v21);
    m3[8] = this.dotVectors3(v12, v22);
    this.freeVector3(v10);
    this.freeVector3(v11);
    this.freeVector3(v12);
    this.freeVector3(v20);
    this.freeVector3(v21);
    this.freeVector3(v22);
    return m3;
  }

  addVector3(v1, v2) {
    var v = this.allocVector3();
    v.setValue(v1.x() + v2.x(), v1.y() + v2.y(), v1.z() + v2.z());
    return v;
  }

  dotVectors3(v1, v2) {
    return v1.x() * v2.x() + v1.y() * v2.y() + v1.z() * v2.z();
  }

  rowOfMatrix3(m, i) {
    var v = this.allocVector3();
    v.setValue(m[i * 3 + 0], m[i * 3 + 1], m[i * 3 + 2]);
    return v;
  }

  columnOfMatrix3(m, i) {
    var v = this.allocVector3();
    v.setValue(m[i + 0], m[i + 3], m[i + 6]);
    return v;
  }

  negativeVector3(v) {
    var v2 = this.allocVector3();
    v2.setValue(-v.x(), -v.y(), -v.z());
    return v2;
  }

  multiplyMatrix3ByVector3(m, v) {
    var v4 = this.allocVector3();
    var v0 = this.rowOfMatrix3(m, 0);
    var v1 = this.rowOfMatrix3(m, 1);
    var v2 = this.rowOfMatrix3(m, 2);
    var x = this.dotVectors3(v0, v);
    var y = this.dotVectors3(v1, v);
    var z = this.dotVectors3(v2, v);
    v4.setValue(x, y, z);
    this.freeVector3(v0);
    this.freeVector3(v1);
    this.freeVector3(v2);
    return v4;
  }

  transposeMatrix3(m) {
    var m2 = [];
    m2[0] = m[0];
    m2[1] = m[3];
    m2[2] = m[6];
    m2[3] = m[1];
    m2[4] = m[4];
    m2[5] = m[7];
    m2[6] = m[2];
    m2[7] = m[5];
    m2[8] = m[8];
    return m2;
  }

  quaternionToMatrix3(q) {
    var m = [];
    var x = q.x();
    var y = q.y();
    var z = q.z();
    var w = q.w();
    var xx = x * x;
    var yy = y * y;
    var zz = z * z;
    var xy = x * y;
    var yz = y * z;
    var zx = z * x;
    var xw = x * w;
    var yw = y * w;
    var zw = z * w;
    m[0] = 1 - 2 * (yy + zz);
    m[1] = 2 * (xy - zw);
    m[2] = 2 * (zx + yw);
    m[3] = 2 * (xy + zw);
    m[4] = 1 - 2 * (zz + xx);
    m[5] = 2 * (yz - xw);
    m[6] = 2 * (zx - yw);
    m[7] = 2 * (yz + xw);
    m[8] = 1 - 2 * (xx + yy);
    return m;
  }

  matrix3ToQuaternion(m) {
    var t = m[0] + m[4] + m[8];
    var s, x, y, z, w;

    if (t > 0) {
      s = Math.sqrt(t + 1.0) * 2;
      w = 0.25 * s;
      x = (m[7] - m[5]) / s;
      y = (m[2] - m[6]) / s;
      z = (m[3] - m[1]) / s;
    } else if (m[0] > m[4] && m[0] > m[8]) {
      s = Math.sqrt(1.0 + m[0] - m[4] - m[8]) * 2;
      w = (m[7] - m[5]) / s;
      x = 0.25 * s;
      y = (m[1] + m[3]) / s;
      z = (m[2] + m[6]) / s;
    } else if (m[4] > m[8]) {
      s = Math.sqrt(1.0 + m[4] - m[0] - m[8]) * 2;
      w = (m[2] - m[6]) / s;
      x = (m[1] + m[3]) / s;
      y = 0.25 * s;
      z = (m[5] + m[7]) / s;
    } else {
      s = Math.sqrt(1.0 + m[8] - m[0] - m[4]) * 2;
      w = (m[3] - m[1]) / s;
      x = (m[2] + m[6]) / s;
      y = (m[5] + m[7]) / s;
      z = 0.25 * s;
    }

    var q = this.allocQuaternion();
    q.setX(x);
    q.setY(y);
    q.setZ(z);
    q.setW(w);
    return q;
  }

}
/**
 * @param {THREE.SkinnedMesh} mesh
 * @param {Ammo.btDiscreteDynamicsWorld} world
 * @param {Object} params
 * @param {ResourceManager} manager
 */


class RigidBody {
  constructor(mesh, world, params, manager) {
    this.mesh = mesh;
    this.world = world;
    this.params = params;
    this.manager = manager;
    this.body = null;
    this.bone = null;
    this.boneOffsetForm = null;
    this.boneOffsetFormInverse = null;

    this._init();
  }
  /**
   * Resets rigid body transform to the current bone's.
   *
   * @return {RigidBody}
   */


  reset() {
    this._setTransformFromBone();

    return this;
  }
  /**
   * Updates rigid body's transform from the current bone.
   *
   * @return {RidigBody}
   */


  updateFromBone() {
    if (this.params.boneIndex !== -1 && this.params.type === 0) {
      this._setTransformFromBone();
    }

    return this;
  }
  /**
   * Updates bone from the current ridid body's transform.
   *
   * @return {RidigBody}
   */


  updateBone() {
    if (this.params.type === 0 || this.params.boneIndex === -1) {
      return this;
    }

    this._updateBoneRotation();

    if (this.params.type === 1) {
      this._updateBonePosition();
    }

    this.bone.updateMatrixWorld(true);

    if (this.params.type === 2) {
      this._setPositionFromBone();
    }

    return this;
  } // private methods


  _init() {
    function generateShape(p) {
      switch (p.shapeType) {
        case 0:
          return new Ammo.btSphereShape(p.width);

        case 1:
          return new Ammo.btBoxShape(new Ammo.btVector3(p.width, p.height, p.depth));

        case 2:
          return new Ammo.btCapsuleShape(p.width, p.height);

        default:
          throw 'unknown shape type ' + p.shapeType;
      }
    }

    const manager = this.manager;
    const params = this.params;
    const bones = this.mesh.skeleton.bones;
    const bone = params.boneIndex === -1 ? new THREE.Bone() : bones[params.boneIndex];
    const shape = generateShape(params);
    const weight = params.type === 0 ? 0 : params.weight;
    const localInertia = manager.allocVector3();
    localInertia.setValue(0, 0, 0);

    if (weight !== 0) {
      shape.calculateLocalInertia(weight, localInertia);
    }

    const boneOffsetForm = manager.allocTransform();
    manager.setIdentity(boneOffsetForm);
    manager.setOriginFromArray3(boneOffsetForm, params.position);
    manager.setBasisFromArray3(boneOffsetForm, params.rotation);
    const vector = manager.allocThreeVector3();
    const boneForm = manager.allocTransform();
    manager.setIdentity(boneForm);
    manager.setOriginFromThreeVector3(boneForm, bone.getWorldPosition(vector));
    const form = manager.multiplyTransforms(boneForm, boneOffsetForm);
    const state = new Ammo.btDefaultMotionState(form);
    const info = new Ammo.btRigidBodyConstructionInfo(weight, state, shape, localInertia);
    info.set_m_friction(params.friction);
    info.set_m_restitution(params.restitution);
    const body = new Ammo.btRigidBody(info);

    if (params.type === 0) {
      body.setCollisionFlags(body.getCollisionFlags() | 2);
      /*
       * It'd be better to comment out this line though in general I should call this method
       * because I'm not sure why but physics will be more like MMD's
       * if I comment out.
       */

      body.setActivationState(4);
    }

    body.setDamping(params.positionDamping, params.rotationDamping);
    body.setSleepingThresholds(0, 0);
    this.world.addRigidBody(body, 1 << params.groupIndex, params.groupTarget);
    this.body = body;
    this.bone = bone;
    this.boneOffsetForm = boneOffsetForm;
    this.boneOffsetFormInverse = manager.inverseTransform(boneOffsetForm);
    manager.freeVector3(localInertia);
    manager.freeTransform(form);
    manager.freeTransform(boneForm);
    manager.freeThreeVector3(vector);
  }

  _getBoneTransform() {
    const manager = this.manager;
    const p = manager.allocThreeVector3();
    const q = manager.allocThreeQuaternion();
    const s = manager.allocThreeVector3();
    this.bone.matrixWorld.decompose(p, q, s);
    const tr = manager.allocTransform();
    manager.setOriginFromThreeVector3(tr, p);
    manager.setBasisFromThreeQuaternion(tr, q);
    const form = manager.multiplyTransforms(tr, this.boneOffsetForm);
    manager.freeTransform(tr);
    manager.freeThreeVector3(s);
    manager.freeThreeQuaternion(q);
    manager.freeThreeVector3(p);
    return form;
  }

  _getWorldTransformForBone() {
    const manager = this.manager;
    const tr = this.body.getCenterOfMassTransform();
    return manager.multiplyTransforms(tr, this.boneOffsetFormInverse);
  }

  _setTransformFromBone() {
    const manager = this.manager;

    const form = this._getBoneTransform(); // TODO: check the most appropriate way to set
    //this.body.setWorldTransform( form );


    this.body.setCenterOfMassTransform(form);
    this.body.getMotionState().setWorldTransform(form);
    manager.freeTransform(form);
  }

  _setPositionFromBone() {
    const manager = this.manager;

    const form = this._getBoneTransform();

    const tr = manager.allocTransform();
    this.body.getMotionState().getWorldTransform(tr);
    manager.copyOrigin(tr, form); // TODO: check the most appropriate way to set
    //this.body.setWorldTransform( tr );

    this.body.setCenterOfMassTransform(tr);
    this.body.getMotionState().setWorldTransform(tr);
    manager.freeTransform(tr);
    manager.freeTransform(form);
  }

  _updateBoneRotation() {
    const manager = this.manager;

    const tr = this._getWorldTransformForBone();

    const q = manager.getBasis(tr);
    const thQ = manager.allocThreeQuaternion();
    const thQ2 = manager.allocThreeQuaternion();
    const thQ3 = manager.allocThreeQuaternion();
    thQ.set(q.x(), q.y(), q.z(), q.w());
    thQ2.setFromRotationMatrix(this.bone.matrixWorld);
    thQ2.conjugate();
    thQ2.multiply(thQ); //this.bone.quaternion.multiply( thQ2 );

    thQ3.setFromRotationMatrix(this.bone.matrix); // Renormalizing quaternion here because repeatedly transforming
    // quaternion continuously accumulates floating point error and
    // can end up being overflow. See #15335

    this.bone.quaternion.copy(thQ2.multiply(thQ3).normalize());
    manager.freeThreeQuaternion(thQ);
    manager.freeThreeQuaternion(thQ2);
    manager.freeThreeQuaternion(thQ3);
    manager.freeQuaternion(q);
    manager.freeTransform(tr);
  }

  _updateBonePosition() {
    const manager = this.manager;

    const tr = this._getWorldTransformForBone();

    const thV = manager.allocThreeVector3();
    const o = manager.getOrigin(tr);
    thV.set(o.x(), o.y(), o.z());

    if (this.bone.parent) {
      this.bone.parent.worldToLocal(thV);
    }

    this.bone.position.copy(thV);
    manager.freeThreeVector3(thV);
    manager.freeTransform(tr);
  }

} //


class Constraint {
  /**
   * @param {THREE.SkinnedMesh} mesh
   * @param {Ammo.btDiscreteDynamicsWorld} world
   * @param {RigidBody} bodyA
   * @param {RigidBody} bodyB
   * @param {Object} params
   * @param {ResourceManager} manager
   */
  constructor(mesh, world, bodyA, bodyB, params, manager) {
    this.mesh = mesh;
    this.world = world;
    this.bodyA = bodyA;
    this.bodyB = bodyB;
    this.params = params;
    this.manager = manager;
    this.constraint = null;

    this._init();
  } // private method


  _init() {
    const manager = this.manager;
    const params = this.params;
    const bodyA = this.bodyA;
    const bodyB = this.bodyB;
    const form = manager.allocTransform();
    manager.setIdentity(form);
    manager.setOriginFromArray3(form, params.position);
    manager.setBasisFromArray3(form, params.rotation);
    const formA = manager.allocTransform();
    const formB = manager.allocTransform();
    bodyA.body.getMotionState().getWorldTransform(formA);
    bodyB.body.getMotionState().getWorldTransform(formB);
    const formInverseA = manager.inverseTransform(formA);
    const formInverseB = manager.inverseTransform(formB);
    const formA2 = manager.multiplyTransforms(formInverseA, form);
    const formB2 = manager.multiplyTransforms(formInverseB, form);
    const constraint = new Ammo.btGeneric6DofSpringConstraint(bodyA.body, bodyB.body, formA2, formB2, true);
    const lll = manager.allocVector3();
    const lul = manager.allocVector3();
    const all = manager.allocVector3();
    const aul = manager.allocVector3();
    lll.setValue(params.translationLimitation1[0], params.translationLimitation1[1], params.translationLimitation1[2]);
    lul.setValue(params.translationLimitation2[0], params.translationLimitation2[1], params.translationLimitation2[2]);
    all.setValue(params.rotationLimitation1[0], params.rotationLimitation1[1], params.rotationLimitation1[2]);
    aul.setValue(params.rotationLimitation2[0], params.rotationLimitation2[1], params.rotationLimitation2[2]);
    constraint.setLinearLowerLimit(lll);
    constraint.setLinearUpperLimit(lul);
    constraint.setAngularLowerLimit(all);
    constraint.setAngularUpperLimit(aul);

    for (let i = 0; i < 3; i++) {
      if (params.springPosition[i] !== 0) {
        constraint.enableSpring(i, true);
        constraint.setStiffness(i, params.springPosition[i]);
      }
    }

    for (let i = 0; i < 3; i++) {
      if (params.springRotation[i] !== 0) {
        constraint.enableSpring(i + 3, true);
        constraint.setStiffness(i + 3, params.springRotation[i]);
      }
    }
    /*
     * Currently(10/31/2016) official ammo.js doesn't support
     * btGeneric6DofSpringConstraint.setParam method.
     * You need custom ammo.js (add the method into idl) if you wanna use.
     * By setting this parameter, physics will be more like MMD's
     */


    if (constraint.setParam !== undefined) {
      for (let i = 0; i < 6; i++) {
        // this parameter is from http://www20.atpages.jp/katwat/three.js_r58/examples/mytest37/mmd.three.js
        constraint.setParam(2, 0.475, i);
      }
    }

    this.world.addConstraint(constraint, true);
    this.constraint = constraint;
    manager.freeTransform(form);
    manager.freeTransform(formA);
    manager.freeTransform(formB);
    manager.freeTransform(formInverseA);
    manager.freeTransform(formInverseB);
    manager.freeTransform(formA2);
    manager.freeTransform(formB2);
    manager.freeVector3(lll);
    manager.freeVector3(lul);
    manager.freeVector3(all);
    manager.freeVector3(aul);
  }

} //


const _position = new THREE.Vector3();

const _quaternion = new THREE.Quaternion();

const _scale = new THREE.Vector3();

const _matrixWorldInv = new THREE.Matrix4();

class MMDPhysicsHelper extends THREE.Object3D {
  /**
   * Visualize Rigid bodies
   *
   * @param {THREE.SkinnedMesh} mesh
   * @param {Physics} physics
   */
  constructor(mesh, physics) {
    super();
    this.root = mesh;
    this.physics = physics;
    this.matrix.copy(mesh.matrixWorld);
    this.matrixAutoUpdate = false;
    this.materials = [];
    this.materials.push(new THREE.MeshBasicMaterial({
      color: new THREE.Color(0xff8888),
      wireframe: true,
      depthTest: false,
      depthWrite: false,
      opacity: 0.25,
      transparent: true
    }));
    this.materials.push(new THREE.MeshBasicMaterial({
      color: new THREE.Color(0x88ff88),
      wireframe: true,
      depthTest: false,
      depthWrite: false,
      opacity: 0.25,
      transparent: true
    }));
    this.materials.push(new THREE.MeshBasicMaterial({
      color: new THREE.Color(0x8888ff),
      wireframe: true,
      depthTest: false,
      depthWrite: false,
      opacity: 0.25,
      transparent: true
    }));

    this._init();
  }
  /**
   * Updates Rigid Bodies visualization.
   */


  updateMatrixWorld(force) {
    var mesh = this.root;

    if (this.visible) {
      var bodies = this.physics.bodies;

      _matrixWorldInv.copy(mesh.matrixWorld).decompose(_position, _quaternion, _scale).compose(_position, _quaternion, _scale.set(1, 1, 1)).invert();

      for (var i = 0, il = bodies.length; i < il; i++) {
        var body = bodies[i].body;
        var child = this.children[i];
        var tr = body.getCenterOfMassTransform();
        var origin = tr.getOrigin();
        var rotation = tr.getRotation();
        child.position.set(origin.x(), origin.y(), origin.z()).applyMatrix4(_matrixWorldInv);
        child.quaternion.setFromRotationMatrix(_matrixWorldInv).multiply(_quaternion.set(rotation.x(), rotation.y(), rotation.z(), rotation.w()));
      }
    }

    this.matrix.copy(mesh.matrixWorld).decompose(_position, _quaternion, _scale).compose(_position, _quaternion, _scale.set(1, 1, 1));
    super.updateMatrixWorld(force);
  } // private method


  _init() {
    var bodies = this.physics.bodies;

    function createGeometry(param) {
      switch (param.shapeType) {
        case 0:
          return new THREE.SphereGeometry(param.width, 16, 8);

        case 1:
          return new THREE.BoxGeometry(param.width * 2, param.height * 2, param.depth * 2, 8, 8, 8);

        case 2:
          return new createCapsuleGeometry(param.width, param.height, 16, 8);

        default:
          return null;
      }
    } // copy from http://www20.atpages.jp/katwat/three.js_r58/examples/mytest37/mytest37.js?ver=20160815


    function createCapsuleGeometry(radius, cylinderHeight, segmentsRadius, segmentsHeight) {
      var geometry = new THREE.CylinderGeometry(radius, radius, cylinderHeight, segmentsRadius, segmentsHeight, true);
      var upperSphere = new THREE.Mesh(new THREE.SphereGeometry(radius, segmentsRadius, segmentsHeight, 0, Math.PI * 2, 0, Math.PI / 2));
      var lowerSphere = new THREE.Mesh(new THREE.SphereGeometry(radius, segmentsRadius, segmentsHeight, 0, Math.PI * 2, Math.PI / 2, Math.PI / 2));
      upperSphere.position.set(0, cylinderHeight / 2, 0);
      lowerSphere.position.set(0, -cylinderHeight / 2, 0);
      upperSphere.updateMatrix();
      lowerSphere.updateMatrix();
      geometry.merge(upperSphere.geometry, upperSphere.matrix);
      geometry.merge(lowerSphere.geometry, lowerSphere.matrix);
      return geometry;
    }

    for (var i = 0, il = bodies.length; i < il; i++) {
      var param = bodies[i].params;
      this.add(new THREE.Mesh(createGeometry(param), this.materials[param.type]));
    }
  }

}

THREE.MMDPhysics = MMDPhysics;
} )();
